/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package managedBean;

import entities.Chanson;
import entities.ListeLecture;
import entities.Utilisateur;
import java.io.Serializable;
import java.net.InetAddress;
import java.util.List;
import javax.annotation.ManagedBean;
import javax.ejb.EJB;
import javax.enterprise.context.SessionScoped;
import javax.faces.application.FacesMessage;

import javax.inject.Named;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import org.primefaces.context.RequestContext;
import org.primefaces.event.DragDropEvent;
import session.ListeLectureManager;
import session.UtilisateurManager;

/**
 *
 * @author Nordinator
 */
@ManagedBean
@Named(value = "userManagedBean")
//@Dependent
@SessionScoped
public class UserManagedBean implements Serializable {

    @EJB
    private UtilisateurManager utilisateurManager;
    private List<Utilisateur> listUser;
    private Utilisateur utilisateur;
    @EJB
    private ListeLectureManager listeLectureManager;
    private List<ListeLecture> collectListeLecture;
    private ListeLecture listeLecture;
    private List<Chanson> tmpSongList;
    private String playListName;
    private String index = "home";
    private String errPage = "loginErrorPage";
    private String username;
    private String password;

    /** Creates a new instance of Mp3LibraryMBean */
    public UserManagedBean() {
    }

    /**
     * Verifie si la personne est bien loggé
     * @return 
     */
    public boolean isLogged() {
        if (utilisateur != null) {
            return true;
        } else {
            return false;
        }
    }
    /**
     * 
     * @return 
     */
    public String redirectCreatePl(){
        if (utilisateur != null) {
            return "createNewPl";
        } else {
            return errPage;
        }
    }
    
    public String redirectSelectPl(){
        if (utilisateur != null) {
            return "selectPlaylist";
        } else {
            return errPage;
        }
    }

    public void setPlayListName(String name) {
        playListName = name;
    }

    public String getPlayListName() {
        return playListName;
    }

    public String getUsername() {
        return username;
    }

    public String getUserName() {
        if (isLogged()) {
            return utilisateur.getName();
        } else {
            return "Mode Invité";
        }
    }

    /**
     * Get the value of tmpSongList
     *
     * @return the value of tmpSongList
     */
    public List<Chanson> getTmpSongList() {
        return tmpSongList;
    }

    /**
     * 
     * @param chanson
     * @return 
     */
    public String addSongIntoPlayer(Chanson chanson) {
        listeLecture = new ListeLecture("tmp");
        listeLecture.addSong(chanson);
        return "PlayerPlaylist";
    }

    /**
     * Set the value of tmpSongList
     *
     * @param tmpSongList new value of tmpSongList
     */
    public void setTmpSongList(List<Chanson> tmpSongList) {
        this.tmpSongList = tmpSongList;
    }

    /**
     * Handler qui renvoi la liste de lecture courante
     * @return 
     */
    public List<Chanson> getCurrentListeLecture() {
        if (listeLecture != null) {
            return listeLecture.getListe();
        }
        return null;
    }

    /**
     * Handler qui permet d'avoir les details sur une playlist
     * @param username 
     */
    public String showListeLectureDetails(ListeLecture liste) {
        listeLecture = liste;
        return "PlayerPlaylist";
    }

    /**
     * 
     * @param username 
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 
     * @return 
     */
    public String getPassword() {
        return password;
    }

    /**
     * 
     * @param password 
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * Méthode récupère la liste des utilisateurs
     * @return
     * 
     */
    public List<Utilisateur> getUsers() {
        //Cette clause est fait pour éviter de recharger plusieurs fois la base pour rien
        if (listUser == null) {
            listUser = utilisateurManager.getAllUtilisateur();
        }
        return listUser;
    }

    /**
     * 
     * @param actionEvent 
     */
    public void login(ActionEvent actionEvent) {
        this.test();
        RequestContext context = RequestContext.getCurrentInstance();
        FacesMessage msg = null;
        boolean loggedIn = false;

        if ((utilisateur = utilisateurManager.getAUser(username, password)) != null) {
            loggedIn = true;
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO, "Welcome", username);
        } else {
            loggedIn = false;
            msg = new FacesMessage(FacesMessage.SEVERITY_WARN, "Login Error", "Invalid credentials");
        }

        FacesContext.getCurrentInstance().addMessage(null, msg);
        context.addCallbackParam("loggedIn", loggedIn);
    }

    /**
     * Cette méthode renvoi les details de l'utilisateur courant
     * @return
     */
    public Utilisateur getDetails() {
        return utilisateur;
    }

    //Partie qui concerne les utilisateurs
    /**
     * Methode d'ajout d'utilisateur en phase avec la page web
     * @return
     */
    public String addNewUSer() {
        utilisateurManager.createUtilisateur(username, password);
        return index;
    }

    /**
     * Cette méthode sauvegarde l'utilisateur courant
     * @return
     */
    public String saveCurrentUser(Utilisateur user) {
        utilisateur = user;
        return index;
    }

    /**
     * Avant de quitter la session il faut ua préalable enregistrer les données
     * @return
     */
    public String logout() {
        utilisateurManager.update(utilisateur);
        utilisateur = null;
        return index;
    }

    //Methodes qui suivent, servent à exécuter lors de la creation d'une playlist
    /**
     * Ajoute la playlist cree a l'utilisateur
     * @return
     */
    public String createPlayList() {
        if(this.isLogged()){
            listeLecture = new ListeLecture(playListName);
            System.out.println("Play list cree : " + playListName);
            return "manageSongIntoPl";
        }else{
            return errPage;
        }
    }

    /**
     * Cette méthode permet d'ajouter une chanson dans un playlist
     * 
     * @return manageSongIntoPl
     */
    public String addSongIntoPlayList(Chanson song) {
        if (listeLecture != null) {
            System.out.println(listeLecture.getName());
            listeLecture.addSong(song);
            System.out.println("La chanson " + song.getTitre() + " a ete ajouter !");
        } else {
            System.out.println("Mp3LibraryMBean.addSongIntoPlayList : Aucune liste de lecture n'a été chargé !");
        }
        return "manageSongIntoPl";
    }

    /**
     *  Cette méthode permet d'ajouter une chanson dans un playlist
     * 
     * @return manageSongIntoPl
     */
    public String removeSongFromPlayList(Chanson song) {
        //N.B : Cette fonction est réservé a ceux qui on un compte
        if (this.isLogged()) {
            if (listeLecture != null) {
                System.out.println(listeLecture.getName());
                listeLecture.removeSong(song);
                System.out.println("La chanson " + song.getTitre() + " a ete retiree !");
            } else {
                System.out.println("Mp3LibraryMBean.removeSongFromPlayList : Aucune liste de lecture n'a été chargé !");
            }
            return "manageSongIntoPl";
        } else {
            return errPage;
        }
    }

    /**
     * 
     * @param ddEvent 
     */
    public void addTmpSongList(DragDropEvent ddEvent) {
        Chanson song = ((Chanson) ddEvent.getData());
        tmpSongList.add(song);
    }

    /**
     * Permute la position de chanson dans la liste de lecture
     * N.B. La playlist devra petre chargé au préalable
     * @return
     */
    public String changePlayListOrder(int song1, int song2) {
        if (listeLecture != null) {
            listeLecture.permutSong(song1, song2);
        } else {
            System.out.println("Mp3LibraryMBean.changePlayListOrder : Aucune PlayList n'a été chargé !");
        }
        return errPage;
    }

    /**
     * 
     */
    public List<Chanson> getDetailsListLecture() {
        if(this.isLogged()){
            return listeLecture.getListe();
        }else{
            System.err.append("Vous n'etes pas logger !");
            return null;
        }
    }

    /**
     * Methode
     * @return
     */
    public String loadAPL(Long idPlayList) {
        if (this.isLogged()) {
            listeLectureManager.getAListeDeLecture(idPlayList);
            return index;
        } else {
            return errPage;
        }
    }
    
    /**
     * Methode qui retourne les playlistes d'un utilisateur
     */
    public List<ListeLecture> getUsersPl(){
        if (this.isLogged()) {
            collectListeLecture = utilisateur.getListesLectures();
            return collectListeLecture;
        } else {
            return null;
        }
    }

    /**
     * 
     * @return 
     */
    public List<ListeLecture> getAllPlayList() {
        if (this.isLogged()) {
            collectListeLecture = listeLectureManager.getAllListeLecture();
            return collectListeLecture;
        } else {
            return null;
        }
    }

    /**
     * Handler de sauvegarde de la playlist
     * @return
     */
    public String savePlayList() {
        if (this.isLogged()) {
            try {
                utilisateur.ajouterListeLecture(listeLecture);
                utilisateurManager.update(utilisateur);
                listeLectureManager.addListeLecture(listeLecture);
                listeLecture = null;
                return index;
            } catch (Exception e) {
                listeLectureManager.update(listeLecture);
                listeLecture = null;
                return index;
            }
        } else {
            return errPage;
        }
    }

    /**
     * permet de charger la page de modif de playlist
     * @return 
     */
    public String loadPlaylist(ListeLecture list) {
        if (this.isLogged()) {
            listeLecture = list;
            return "manageSongIntoPl";
        } else {
            return errPage;
        }
    }

    /**
     * Charger toute les playList d'un utilisateur
     * @return 
     */
    public String getAllPlayListFromUser() {
        return index;
    }

    /**
     * 
     * @param list
     * @return 
     */
    public String removePlaylist(ListeLecture list) {
        listeLectureManager.effacerListeLecture(list);
        return "selectPlaylist";
    }

    /**
     * Methode de test de fonction
     */
    public void test() {
        listeLectureManager.Test();
    }
}